import { RouteRecordRaw } from 'vue-router'

import { Loading } from '@/utils/loading'
import { Session } from '@/utils/storage'
import { storeToRefs } from 'pinia'
import { useUserStore } from '@/stores/modules/userStore'
import { useRouteStore } from '@/stores/modules/routeStore'
import { useTagViewStore } from '@/stores/modules/tagViewStore'
import { router } from '@/router/index'
import { dynamicRoutes, notFoundAndNoPower } from '@/router/route'
import { TOKEN_KEY } from '@/constants'
import { useKeepAliveStore } from '@/stores/modules/keepAliveStore'
/**
 * 前端路由初始化方法：防止刷新页面路由丢失
 * @method  NextLoading 界面 loading 动画开始执行
 * @method useUserInfo(pinia).setUserInfos() 触发初始化用户信息 pinia
 * @method setAddRoute 添加动态路由
 * @method setFilterMenuAndCacheTagsViewRoutes 设置递归过滤有权限的路由到 pinia routesList 中（已处理成多级嵌套路由）及缓存多级嵌套数组处理后的一维数组
 */
export async function initFrontEndControlRoutes() {
    // 界面 loading 动画开始执行
    if (window.Loading === undefined) Loading.start()
    // 无 token 停止执行下一步
    if (!Session.get(TOKEN_KEY)) return false
    const userStore = useUserStore()
    // 触发初始化用户信息 pinia
    await userStore.setUserInfo()
    const roles: any = userStore.userInfo?.roles
    // 无登录权限时，添加判断
    if (roles.length <= 0) return Promise.resolve(true)
    // 添加动态路由
    await setAddRoute()
    // 设置递归过滤有权限的路由到 pinia routesList 中（已处理成多级嵌套路由）及缓存多级嵌套数组处理后的一维数组
    setFilterMenuAndCacheTagsViewRoutes()
}

/**
 * 添加动态路由
 */
export async function setAddRoute() {
    await setFilterRouteEnd().forEach((route: RouteRecordRaw) => {
        router.addRoute(route)
    })
}

/**
 * 获取当前用户权限标识去比对路由表（未处理成多级嵌套路由）
 * @description 这里主要用于动态路由的添加，router.addRoute
 * @param chil dynamicRoutes（/@/router/route）第一个顶级 children 的下路由集合
 * @returns 返回有当前用户权限标识的路由数组
 */
export function setFilterRoute(chil: any) {
    const stores = useUserStore()
    const { userInfo } = storeToRefs(stores)
    const filterRoute: any = []
    chil.forEach((route: any) => {
        if (route.meta.roles) {
            route.meta.roles.forEach((metaRoles: any) => {
                userInfo.value.roles.forEach((roles: any) => {
                    if (metaRoles === roles) filterRoute.push({ ...route })
                })
            })
        }
    })
    return filterRoute
}

/**
 * 获取有当前用户权限标识的路由数组，进行对原路由的替换
 * @description 替换 dynamicRoutes（/@/router/route）第一个顶级 children 的路由
 * @returns 返回替换后的路由数组
 */
export function setFilterRouteEnd() {
    const filterRouteEnd: any = formatTwoStageRoutes(formatFlatteningRoutes(dynamicRoutes))
    // notFoundAndNoPower 防止 404、401 不在 layout 布局中，不设置的话，404、401 界面将全屏显示
    // 关联问题 No match found for location with path 'xxx'
    filterRouteEnd[0].children = [...setFilterRoute(filterRouteEnd[0].children), ...notFoundAndNoPower]
    return filterRouteEnd
}

/**
 * 设置递归过滤有权限的路由到 pinia routesList 中（已处理成多级嵌套路由）及缓存多级嵌套数组处理后的一维数组
 * @description 用于左侧菜单、横向菜单的显示
 * @description 用于 tagsView、菜单搜索中：未过滤隐藏的(isHide)
 */
export function setFilterMenuAndCacheTagsViewRoutes() {
    const userStore = useUserStore()
    const storesRouteList = useRouteStore()
    const { userInfo } = storeToRefs(userStore)
    storesRouteList.setRouteList(setFilterHasRolesMenu(dynamicRoutes[0].children, userInfo.value.roles))
    setCacheTagsViewRoutes()
}

/**
 * 判断路由 `meta.roles` 中是否包含当前登录用户权限字段
 * @param roles 用户权限标识，在 userInfos（用户信息）的 roles（登录页登录时缓存到浏览器）数组
 * @param route 当前循环时的路由项
 * @returns 返回对比后有权限的路由项
 */
export function hasRoles(roles: any, route: any) {
    if (route.meta && route.meta.roles) return roles.some((role: any) => route.meta.roles.includes(role))
    else return true
}

/**
 * 获取当前用户权限标识去比对路由表，设置递归过滤有权限的路由
 * @param routes 当前路由 children
 * @param roles 用户权限标识，在 userInfos（用户信息）的 roles（登录页登录时缓存到浏览器）数组
 * @returns 返回有权限的路由数组 `meta.roles` 中控制
 */
export function setFilterHasRolesMenu(routes: any, roles: any) {
    const menu: any = []
    routes.forEach((route: any) => {
        const item = { ...route }
        if (hasRoles(roles, item)) {
            if (item.children) item.children = setFilterHasRolesMenu(item.children, roles)
            menu.push(item)
        }
    })
    return menu
}

/**
 * 缓存多级嵌套数组处理后的一维数组
 * @description 用于 tagsView、菜单搜索中：未过滤隐藏的(isHide)
 */
export function setCacheTagsViewRoutes() {
    // 获取有权限的路由，否则 tagsView、菜单搜索中无权限的路由也将显示
    const stores = useUserStore()
    const storesTagsView = useTagViewStore()
    const { userInfo } = storeToRefs(stores)
    const rolesRoutes = setFilterHasRolesMenu(dynamicRoutes, userInfo.value.roles)
    // 添加到 pinia setTagsViewRoutes 中
    storesTagsView.setTagsViewRoutes(formatTwoStageRoutes(formatFlatteningRoutes(rolesRoutes))[0].children)
}

/**
 * 路由多级嵌套数组处理成一维数组
 * @param arr 传入路由菜单数据数组
 * @returns 返回处理后的一维路由菜单数组
 */
export function formatFlatteningRoutes(arr: any) {
    if (arr.length <= 0) return false
    for (let i = 0; i < arr.length; i++) {
        if (arr[i].children) {
            arr = arr.slice(0, i + 1).concat(arr[i].children, arr.slice(i + 1))
        }
    }
    return arr
}

/**
 * 一维数组处理成多级嵌套数组（只保留二级：也就是二级以上全部处理成只有二级，keep-alive 支持二级缓存）
 * @description isKeepAlive 处理 `name` 值，进行缓存。顶级关闭，全部不缓存
 * @param arr 处理后的一维路由菜单数组
 * @returns 返回将一维数组重新处理成 `定义动态路由（dynamicRoutes）` 的格式
 */
export function formatTwoStageRoutes(arr: any) {
    if (arr.length <= 0) return false
    const newArr: any = []
    const cacheList: Array<string> = []
    arr.forEach((v: any) => {
        if (v.path === '/') {
            newArr.push({
                component: v.component,
                name: v.name,
                path: v.path,
                redirect: v.redirect,
                meta: v.meta,
                children: [],
            })
        } else {
            // 判断是否是动态路由（xx/:id/:name），用于 tagsView 等中使用
            if (v.path.indexOf('/:') > -1) {
                v.meta['isDynamic'] = true
                v.meta['isDynamicPath'] = v.path
            }
            newArr[0].children.push({ ...v })
            // 存 name 值，keep-alive 中 include 使用，实现路由的缓存
            // 路径：/@/layout/routerView/parent.vue
            if (newArr[0].meta.isKeepAlive && v.meta.isKeepAlive) {
                cacheList.push(v.name)
                const keepAliveStore = useKeepAliveStore()
                keepAliveStore.setCacheKeepAlive(cacheList)
            }
        }
    })
    return newArr
}
